home *** CD-ROM | disk | FTP | other *** search
/ Greenhouse Effect Detection Expriment / NASA Greenhouse Effect Detection Expriment 1992 - Disc 2.iso / software / dos / cdf22pc / src / tools / var_data.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-03-02  |  8.0 KB  |  336 lines
  1.  
  2. /******************************************************************************
  3. *
  4. *  NSSDC/CDF                        Variable data processing.
  5. *
  6. *  Version 2.0, 3-Mar-92, ST Systems (STX)
  7. *
  8. *  Modification history:
  9. *
  10. *   V1.0  29-Jan-91, D Grogan/H Leckner       Original version (for CDF V2.0).
  11. *   V1.1  25-Mar-91, J Love           Cast malloc calls.
  12. *   V1.2  25-Jun-91, J Love           Removed 'kb_def_user.h'.
  13. *   V1.3  28-Jun-91, J Love           TRUE/FALSE.
  14. *   V2.0   3-Mar-92, J Love           Modified for IBM-PC port.  CDF V2.2.
  15. *             H Leckner
  16. *
  17. ******************************************************************************/
  18.  
  19. #if defined (ultrix)
  20. #include <cursesX.h>
  21. #else
  22. #if defined (unix)
  23. #include <curses.h>
  24. #endif
  25. #endif
  26.  
  27. #include <stdlib.h>
  28. #include <stdio.h>
  29.  
  30. #include "cdfdist.h"
  31. #include "wfl.h"
  32. #include "cdfdist.h"
  33. #include "kb_def.h"
  34. #include "cdfbrow.h"
  35.  
  36. #define MAX_ELEMENTS    14
  37. #define FIRST_ELEMENT    2
  38. #define DATATYPE    4
  39. #define NUMBYTES    5
  40. #define    CP    (*c)
  41. void VAR_DATA_open(var_ptr, cdf_name)
  42.  
  43.     struct var_total_struct **var_ptr;
  44.     char            cdf_name[];
  45.  
  46. {
  47.     struct var_data_struct    *c;
  48.     /*FILE         *fptr;*/
  49.     FILE        *fopen();
  50.     long int    buf_size;
  51.  
  52.     /*long int    i;*/
  53.  
  54.     buf_size = sizeof(struct var_total_struct);
  55.     *var_ptr = (struct var_total_struct *) malloc(buf_size);     /* V1.1 */
  56.     buf_size = sizeof(struct var_data_struct);
  57.     (**var_ptr).var_data_ptr =
  58.         (struct var_data_struct *) malloc(buf_size);      /* V1.1 */
  59.     c = (**var_ptr).var_data_ptr;
  60. /*    fptr = fopen("filename.dat","r");
  61.     if(fptr == NULL)
  62.        {
  63.        printf ("Error openning for read\n"); */
  64.  
  65.        strcpy(CP.cdf_name,cdf_name);
  66.        strcpy(CP.var_mnemonic," ");
  67.        strcpy(CP.data_type,"REAL*4");
  68.        CP.num_bytes = 4;
  69.        strcpy(CP.fieldnam," ");
  70.        strcpy(CP.units," ");
  71.        strcpy(CP.format," ");
  72.        strcpy(CP.record_variance,"T");
  73.        strcpy(CP.dim_variance,"FFFFFFFFFF");
  74.        CP.validmin = 0.;
  75.        CP.validmax = 100.;
  76.        CP.scalemin = 0.;
  77.        CP.scalemax = 0.;
  78.        strcpy(CP.catdesc," ");
  79.        CP.field_address = 0;
  80.        CP.field_len = 0;
  81.        strcpy(CP.dec_routine," ");
  82.        strcpy(CP.dec_datatype,"REAL*4");
  83.        strcpy(CP.dec_vartype,"D");
  84. /*       }
  85.  
  86.     else
  87.        {
  88.         fread (*c, buf_size, 1, fptr);
  89.         fclose (fptr);
  90.        } */
  91.        VAR_FORM_init((struct var_form_struct **) &(**var_ptr).var_screen_ptr);
  92. }
  93.  
  94. void VAR_DATA_display ( var_ptr, var_num)
  95.  
  96.     struct var_total_struct *var_ptr;
  97.     long int        *var_num;
  98. {
  99.     struct var_data_struct    *c;
  100.     /*long int    *page;*/
  101.     int        element;
  102.     int        data_type;    /* DT_STRING:string,
  103.                        DT_LONGINT: int, DT_FLOAT: float */
  104.  
  105.     c = (*var_ptr).var_data_ptr;
  106.  
  107.     VAR_FORM_load_form((struct var_form_struct *) (*var_ptr).var_screen_ptr);
  108.  
  109. /*
  110.     Display cdf_name data
  111. */
  112.     element = 1;
  113.     data_type = DT_STRING;
  114.     VAR_FORM_display_element( (long *) CP.cdf_name, data_type, element,
  115.         (struct var_form_struct *)(*var_ptr).var_screen_ptr);
  116.  
  117. /*
  118.     Display page num
  119. */
  120.     element = 2;
  121.     data_type = DT_LONGINT;
  122.     VAR_FORM_display_element( var_num, data_type, element,
  123.             (struct var_form_struct *)(*var_ptr).var_screen_ptr);
  124.  
  125. /*
  126.     Display var_mnemonic
  127. */
  128.     element = 3;
  129.     data_type = DT_STRING;
  130.     VAR_FORM_display_element( (long *)CP.var_mnemonic, data_type, element,
  131.             (struct var_form_struct *)(*var_ptr).var_screen_ptr);
  132.  
  133. /*
  134.     Display data type
  135. */
  136.     element = 4;
  137.     data_type = DT_STRING;
  138.  
  139.     VAR_FORM_display_element( (long *)CP.data_type, data_type, element,
  140.             (struct var_form_struct *)(*var_ptr).var_screen_ptr);
  141. /*
  142.     Display number of bytes
  143. */
  144.     element = 5;
  145.     data_type = DT_LONGINT;
  146.  
  147.     VAR_FORM_display_element( &CP.num_bytes, data_type, element,
  148.         (struct var_form_struct *)(*var_ptr).var_screen_ptr);
  149. /*
  150.     Display fieldname
  151. */
  152.     element = 6;
  153.     data_type = DT_STRING;
  154.  
  155.     VAR_FORM_display_element( (long *)CP.fieldnam, data_type, element,
  156.         (struct var_form_struct *)(*var_ptr).var_screen_ptr);
  157.  
  158. /*
  159.     Display units
  160. */
  161.     element = 7;
  162.     data_type = DT_STRING;
  163.  
  164.     VAR_FORM_display_element( (long *)CP.units, data_type, element,
  165.         (struct var_form_struct *)(*var_ptr).var_screen_ptr);
  166.  
  167. /*
  168.     Display format
  169. */
  170.     element = 8;
  171.     data_type = DT_STRING;
  172.  
  173.     VAR_FORM_display_element( (long *)CP.format, data_type, element,
  174.         (struct var_form_struct *)(*var_ptr).var_screen_ptr);
  175.  
  176. /*
  177.     Display record variance
  178. */
  179.     element = 9;
  180.     data_type = DT_STRING;
  181.  
  182.     VAR_FORM_display_element( (long *)CP.record_variance, data_type,
  183.     element, (struct var_form_struct *)(*var_ptr).var_screen_ptr);
  184.  
  185. /*
  186.     Display dimension variance
  187. */
  188.     element = 10;
  189.     data_type = DT_STRING;
  190.  
  191.     VAR_FORM_display_element( (long *)CP.dim_variance, data_type,
  192.     element, (struct var_form_struct *)(*var_ptr).var_screen_ptr);
  193.  
  194. /*
  195.     Display validmin
  196. */
  197.     element = 11;
  198.     data_type = DT_FLOAT;
  199.  
  200.     VAR_FORM_display_element( (long *)&CP.validmin, data_type, element,
  201.         (struct var_form_struct *)(*var_ptr).var_screen_ptr);
  202. /*
  203.     Display validmax
  204. */
  205.     element = 12;
  206.     data_type = DT_FLOAT;
  207.  
  208.     VAR_FORM_display_element( (long *)&CP.validmax, data_type, element,
  209.         (struct var_form_struct *)(*var_ptr).var_screen_ptr);
  210. /*
  211.     Display scalemin
  212. */
  213.     element = 13;
  214.     data_type = DT_FLOAT;
  215.  
  216.     VAR_FORM_display_element( (long *)&CP.scalemin, data_type, element,
  217.         (struct var_form_struct *)(*var_ptr).var_screen_ptr);
  218. /*
  219.     Display scalemax
  220. */
  221.     element = 14;
  222.     data_type = DT_FLOAT;
  223.  
  224.     VAR_FORM_display_element( (long *)&CP.scalemax, data_type, element,
  225.         (struct var_form_struct *)(*var_ptr).var_screen_ptr);
  226. }
  227. void VAR_DATA_read ( var_ptr, var_num)
  228.  
  229.     struct var_total_struct *var_ptr;
  230.     long int        *var_num;
  231. {
  232.  
  233.     struct var_data_struct    *c;
  234.     struct    read_data
  235.         {
  236.         long int    data_type;
  237.         long int    *data;
  238.         } elem_data[MAX_ELEMENTS];
  239.  
  240.     long int    *form_ptr;
  241.     int        element;
  242.     int        data_type;    /* DT_STRING:string,
  243.                     DT_LONGINT: int, DT_FLOAT: float */
  244.     int        rcode;
  245.     int        element_count = FIRST_ELEMENT;
  246.     /*long int    page;*/
  247.     long int    done = FALSE;
  248.     char        string_val[7];
  249.     /*int        strcmp();*/
  250.     int        num_bytes;
  251.     strcpy(string_val,"STRING\0");
  252.  
  253.     c = (*var_ptr).var_data_ptr;
  254.     form_ptr = (*var_ptr).var_screen_ptr;
  255.  
  256. /*
  257.    Transfer pointers of allocated memory into temporary storage
  258.    defined for each element number
  259. */
  260.  
  261.     elem_data[1].data_type = DT_LONGINT;
  262.     elem_data[2].data_type = DT_STRING;
  263.     elem_data[3].data_type = DT_STRING;
  264.     elem_data[4].data_type = DT_LONGINT;
  265.     elem_data[5].data_type = DT_STRING;
  266.     elem_data[6].data_type = DT_STRING;
  267.     elem_data[7].data_type = DT_STRING;
  268.     elem_data[8].data_type = DT_STRING;
  269.     elem_data[9].data_type = DT_STRING;
  270.     elem_data[10].data_type = DT_FLOAT;
  271.     elem_data[11].data_type = DT_FLOAT;
  272.     elem_data[12].data_type = DT_FLOAT;
  273.     elem_data[13].data_type = DT_FLOAT;
  274.     elem_data[1].data = var_num;
  275.     elem_data[2].data = (long int *) CP.var_mnemonic;
  276.     elem_data[3].data = (long int *) CP.data_type;
  277.     elem_data[4].data = &CP.num_bytes;
  278.     elem_data[5].data = (long int *) CP.fieldnam;
  279.     elem_data[6].data = (long int *) CP.units;
  280.     elem_data[7].data = (long int *) CP.format;
  281.     elem_data[8].data = (long int *) CP.record_variance;
  282.     elem_data[9].data = (long int *) CP.dim_variance;
  283.     elem_data[10].data = (long int *) &CP.validmin;
  284.     elem_data[11].data = (long int *) &CP.validmax;
  285.     elem_data[12].data = (long int *) &CP.scalemin;
  286.     elem_data[13].data = (long int *) &CP.scalemax;
  287.  
  288.     while ( done != TRUE)
  289.         {
  290.  
  291.         element = element_count;
  292.         data_type = elem_data[element_count-1].data_type;
  293.  
  294.         VAR_FORM_read_element( elem_data[element_count-1].data,
  295.          data_type, element, (struct var_form_struct * )form_ptr,
  296.          &rcode);
  297.  
  298.         if(element_count == DATATYPE)
  299.               {
  300. /*
  301.   Retrieve number of bytes for a specified data type
  302. */
  303.               VAR_FORM_get_nbytes((char *) elem_data[element_count-1].data,
  304.               (struct var_form_struct * )form_ptr, element_count,
  305.                 &num_bytes);
  306.               data_type = DT_LONGINT;
  307.               if(num_bytes > 0)
  308.               VAR_FORM_display_element( (long *)&num_bytes, data_type,
  309.               NUMBYTES, (struct var_form_struct * )form_ptr);
  310.               }
  311.  
  312.         done = WFL_rove_form (rcode, &element_count,
  313.             FIRST_ELEMENT, MAX_ELEMENTS, 1);
  314.  
  315.         if (element_count == NUMBYTES && num_bytes > 0)
  316.            {
  317.            if ( (rcode == KBF_NEXTFIELD)/*  ||
  318.             (rcode == KBF_DOWN)*/ )
  319.              element_count ++;
  320.  
  321.            if ( (rcode == KBF_PREVFIELD)/*  ||
  322.             (rcode == KBF_UP)*/   )
  323.              element_count --;
  324.            }
  325.         }
  326.  
  327. }
  328.  
  329.  
  330. void VAR_DATA_erase ( var_ptr )
  331.  
  332.     struct var_total_struct *var_ptr;
  333. {
  334.     VAR_FORM_erase_form((struct var_form_struct *)(*var_ptr).var_screen_ptr );
  335. }
  336.